#ifndef CARTE_ZONE_H
#   define CARTE_ZONE_H


#include <stdio.h>

#include "cases.h"
#include "base_donnees.h"



/**
 * \file carte_zone.h
 * Ce module permet de manipuler des structures carte_zone.
 * Ces structures contiennent, le temps d'une bataille, des informations
 * telles que la position et la nature du decor, les caracteristiques de
 * la zone dans laquelle la bataille se deroule, etc.
 * A noter que les informations sur les ennemis  et le joueur sont dans les
 * structure etat_bataille et etat_partie.
 * Une structure carte_zone doit etre cree avant chaque bataille et n'est
 * d'aucune utilite une fois celle-ci terminee. Elle doit donc etre detruite a
 * l'issue de la bataille.
 *
 * Utilisation :
 *
 * 1) Charger une carte avec charger_carte_zone, dont certains arguments
 * permettent de designer un numero de region et le numero de zone a charger
 * (rappel : le jeu contient plusieurs regions, chacune divisee en plusieurs
 * zones reliees entre elles d'une maniere decrite par leurs coordonnees dans la
 * region et leurs "raccords"). Cette fonction se charge elle-meme d'appeler
 * les fonctions d'initialisation. Il suffit de lui donner l'adresse d'une
 * structure carte_zone, qui n'a pas besoin d'etre placee dans le tas ni d'etre
 * manipulee avant l'appel de la fonction de chargement.
 *
 * IMPORTANT : charger_carte_zone initialise elle-meme l'etat_bataille qui lui
 * est donne, et le rempli (en tout cas, elle le met dans les conditions du
 * debut de la bataille).
 *
 * 2) Utiliser la carte zone durant la bataille. Beaucoup de fonctions
 * permettant de consulter la nature du decor en des endroits donnes se
 * trouvent dans le module manipulation_cases.
 *
 * 3) Detruire la carte zone avec detruire_carte_zone. Cette fonction appelle
 * toutes les fonctions necessaires a la liberation de la memoire allouee pour
 * les champs de la carte_zone. Puisque carte_zone n'est pas fait pour etre
 * elle-meme placee dans le tas, celle fonction ne tente pas de la liberer.
 */





/**
 * \struct carte_zone carte_zone.h
 * Structure destinee a contenir, durant toute une bataille,
 * les informations liees a la zone : ses dimensions, les elements
 * qui la composent, ou encore ce qu'on gagne la premiere fois qu'on
 * la termine. Elle est detruite en fin de bataille.
 */
struct carte_zone
{
    /** dimensions, en nombre de cases, de la zone */
    unsigned int dim_x;
    /** dimensions, en nombre de cases, de la zone */
    unsigned int dim_y;

    /**
     * grille_cases_constantes est destine a pointer sur
     * une allocation de dim_x * dim_y petits entiers
     */
    unsigned char* grille_cases_constantes;

    /**
     * tableau de pointeurs sur les stats des elements destructibles.
     * Si une case n'en contient pas (ce qui sera frequent),
     * on trouvera NULL dans la case correspondante de ce tableau.
     * A noter qu'il a les memes dimensions que celui des cases constantes.
     * REMARQUE : chaque structure case_destructible
     *            sera allouee individuellement
     */
    struct case_destructible** grille_cases_destructibles;

    /**
     * informations sur chaque type
     * de case constante que l'on peut trouver dans la zone.
     * Les entiers de grille_cases_constantes font reference a la position
     * dans liste_infos_cases_constantes a laquelle on peut trouver la
     * description de la case concernee. Cela permet d'eviter d'avoir a
     * stocker de nombreuses fois les memes informations
     */
    struct tab_dyn_cases_constantes liste_infos_cases_constantes;

    /**
     * tableau contenant les id des objets obtenus en cas de victoire
     * dans cette zone.
     * REMARQUE : on ne peut pas les gagner plusieurs fois !
     */
    struct tab_dyn_id tab_objets_zone;

    /** somme d'argent remportee lors de la premiere victoire dans cette zone */
    unsigned int argent_zone;

    /**
     * VRAI si la zone concernee est celle permettant de considerer
     * que le joueur a termine la region, FAUX sinon
     */
    unsigned char boss;

    /**
     * VRAI si le joueur a deja remporte la victoire dans la zone concernee,
     * FAUX sinon. Permet de gerer les fins de regions et les gains d'objets
     */
    unsigned char deja_visitee;

    /**
     * liste des id des ennemis present en debut de bataille. Sert a gerer les
     * gains d'objets et d'experience a la fin de la bataille si elle est
     * remportee
     */
    struct tab_dyn_id liste_id_ennemis;
};


/**
 * \fn void set_dim_carte_zone(struct carte_zone* carte, unsigned int x, unsigned int y)
 * \brief Procedure permettant de remplir les champs de dimension d'une zone
 *
 * \param[out] carte La carte dont on veut regler la dimension
 * \param[in] x Dimension suivant l'axe des x
 * \param[in] y Dimension suivant l'axe des y
 */
void set_dim_carte_zone(struct carte_zone* carte, const unsigned int x, const unsigned int y);


/**
 * \fn char est_dans_carte(const int x,
                                  const int y, const struct carte_zone* carte)
 * \brief Dit si les coordonnees d'une case font reference a
 *        l'interieur ou a l'exterieur d'une carte
 *
 * \param[in] x Coordonnee horizontale, en nombre de cases
 * \param[in] y Coordonnee verticale, en nombre de cases
 * \param[in] carte L'adresse de la carte concernee
 * \return VRAI si la case est dans la carte, FAUX sinon
 */
char est_dans_carte(const int x, const int y, const struct carte_zone* carte);


/**
 * \fn void init_carte_zone(struct carte_zone* carte, unsigned int x, unsigned int y)
 * \brief Initialise une carte de zone (ne la remplie pas, mais la prepare a etre remplie)
 *
 * \param[out] carte La carte qu'on veut preparer a etre remplie
 * \param[in] x Dimension de la zone suivant l'axe des x
 * \param[in] y Dimension de la zone suivant l'axe des y
 */
void init_carte_zone(struct carte_zone* carte, unsigned int x, unsigned int y);


/**
 * \fn void detruire_carte_zone(struct carte_zone* carte)
 * \brief Procedure liberant la memoire alouee pour les champs d'une carte_zone
 *
 * \param[in] carte Un pointeur sur la carte_zone dont on veut s'occuper
 */
void detruire_carte_zone(struct carte_zone* carte);




/**
 * \fn void mettre_contour_et_remplir(struct carte_zone* carte)
 * \brief Remplis le contour de la grille de cases constantes avec le type de
case choisi pour cela et remplit le reste avec le type de case destine au remplissage
 *
 * \param[in,out] carte Un pointeur sur la carte_zone dont on veut s'occuper
 */
void mettre_contour_et_remplir(struct carte_zone* carte);





#endif /* CARTE_ZONE_H */
